Instance 0

Class220.paint(Graphics g)#4{
                g2.setColor(new Color(255, 255, 255, 100));
                g2.fill(triangle);
                g2.setColor(Color.BLACK);
                g2.draw(triangle);
}


Instance 1

Class210.drawPath(final boolean isCurrent,Graphics2D g2d,final GeneralPath gp,final float offsetX)#2{
            g2d.setColor(new Color(255, 200, 200, 30));
            g2d.setColor(new Color(255, 255, 255, 30));
        g2d.fill(gp);
}


Instance 2

Class60.paintControlPoint(Graphics2D g2,Point2D control)#5{
            g2.setColor(new Color(1.0f, 1.0f, 1.0f, 1.0f));
            g2.setColor(new Color(0.8f, 0.8f, 0.8f, 0.6f));
        g2.fill(inner);
}


Instance 3

Class590.paintComponent(Graphics g)#1{
        Graphics2D g2d = (Graphics2D)g;
        g2d.translate(startX, startY);
        g2d.rotate(Math.atan2(ey, ex));
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setComposite(composite);
        g2d.setColor(this.color);
        g2d.fill(arrow);
        g2d.setColor(Color.BLACK);
        g2d.draw(arrow);
}


Instance 4

Class420.drawTextBox(Graphics2D g2D,String text,int x0,int y0,Color color)#0{
        final FontMetrics fontMetrics = g2D.getFontMetrics();
        final Rectangle2D textBounds = fontMetrics.getStringBounds(text, g2D);
        x0 -= textBounds.getWidth() / 2;
        textBounds.setRect(textBounds.getX() - 1, textBounds.getY(), textBounds.getWidth(), textBounds.getHeight());
        Rectangle2D.Double r = new Rectangle2D.Double(x0 + textBounds.getX() - 2.0,
                                                      y0 + textBounds.getY() - 2.0,
                                                      textBounds.getWidth() + 4.0,
                                                      textBounds.getHeight() + 4.0);
        if (r.getMaxX() > getWidth()) {
            r.setRect(getWidth() - r.getWidth(), r.getY(), r.getWidth(), r.getHeight());
        }
        if (r.getMinX() < 0) {
            r.setRect(0, r.getY(), r.getWidth(), r.getHeight());
        }
        if (r.getMaxY() > getHeight()) {
            r.setRect(r.getX(), getHeight() - r.getHeight(), r.getWidth(), r.getHeight());
        }
        if (r.getMinY() < 0) {
            r.setRect(r.getX(), 0, r.getWidth(), r.getHeight());
        }
        g2D.setColor(color);
        g2D.fill(r);
        g2D.setColor(Color.black);
        g2D.draw(r);
        g2D.drawString(text, x0, y0);
}


Instance 5

Class180.paintLowerThumb(Graphics g)#1{
            g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);
            g2d.translate(knobBounds.x, knobBounds.y);
            g2d.setColor(Color.CYAN);
            g2d.fill(thumbShape);
            g2d.setColor(Color.BLUE);
            g2d.draw(thumbShape);
            g2d.dispose();
}


Instance 6

Class470.paintComponent(Graphics g)#1{
            for (int i = 0; i < ticker.length; i++) {
                int channel = 224 - (128 / (i + 1));
                g2.setColor(new Color(channel, channel, channel, 100));
                g2.fill(ticker[i]);


                try {
                    Rectangle2D bounds = ticker[i].getBounds2D();

                    if (bounds.getMaxY() > maxY) {
                        maxY = bounds.getMaxY();
                    }
                } catch (ArrayIndexOutOfBoundsException ae) {
                    //
                }
            }
            g2.setColor(UIHelper.GREY_COLOR);
            g2.setFont(UIHelper.VER_10_BOLD);
            FontMetrics fm = g2.getFontMetrics(g2.getFont());
            int stringSize = fm.stringWidth(text);
}


Instance 7

Class50.paintComponent(Graphics graphics)#2{
    g.setColor(FILL_COLOR);
    g.fill(drawRect);
    g.setColor(DRAW_COLOR);
    g.draw(drawRect);
    g.dispose();    
}


Instance 8

Class740.paint(Graphics2D g)#1{
    g2d.setColor(Color.green.darker());
    g2d.fill(dotShape);
    g2d.setColor(Color.black);
    g2d.draw(dotShape);
    g2d.dispose();
}


Instance 9

Class230.paint(Graphics g)#2{
                g2d.setColor(new Color(255, 255, 255, 128));
                g2d.fill(s);
                g2d.setColor(Color.black);
}


Instance 10

Class170.drawAlgoState(Graphics2D g2,SortingWorld world,int maxSize)#0{
      g2.setColor( values[i]==i ? Color.GREEN : Color.RED) ;
      g2.fill(rect);
      g2.setColor(Color.black);
      g2.draw(rect);
      if (scale > 20) 
        g2.drawString(val2str(values[i],world.getValueCount()) , (int)scale*i+(int)scale/2, maxSize-2);
}


Instance 11

Class670.drawBB(java.awt.Graphics2D g,ProjectionRect bb,Color fillColor)#1{
    if (null != fillColor) {
      g.setColor(fillColor);
      g.fill(rect);
    }
    g.setColor(outlineColor);
    g.draw(rect);
}


Instance 12

Class20.paint(Graphics2D g,Rectangle2D rect,String text)#0{
        textBounds = new Rectangle2D.Double(
            x + textBounds.getX(),
            y + textBounds.getY(),
            textBounds.getWidth(),
            textBounds.getHeight()
        );
        RoundRectangle2D background = new RoundRectangle2D.Double(
            textBounds.getX() - ArcRadius / 2,
            textBounds.getY() - ArcRadius / 2,
            textBounds.getWidth() + ArcRadius,
            textBounds.getHeight() + ArcRadius,
            ArcRadius, ArcRadius
        );
        Color oldColor = g.getColor();
        g.setColor(BackColor);
        g.fill(background);
        g.setColor(TextColor);
}


Instance 13

Class250.paintIcon(Component c,Graphics g,int x,int y)#1{
            Graphics2D graphics = (Graphics2D)g;
            graphics.setColor(SwingTools.LIGHT_BLUE);
            graphics.fill(arrowShape);
            graphics.setColor(SwingTools.DARK_BLUE);
            graphics.draw(arrowShape);
            g.translate(-x, -y);
}


Instance 14

Class450.paintTrack(Graphics g,JComponent c,Rectangle trackBounds){
        Graphics2D g2 = (Graphics2D) g;
        g2.setColor(background);
        g2.fill(trackBounds);
        g2.setColor(foreground);
        g2.draw(trackBounds);
}


Instance 15

Class600.drawNominalLegend(Graphics graphics,DataTable table,int legendColumn,int xOffset,int alpha)#3{
            Color color = getColorProvider().getPointColor((double) i / (double) (numberOfValues - 1), alpha);
            g.setColor(color);
            g.fill(colorBullet);
            g.setColor(Color.black);
            g.draw(colorBullet);
            g.drawString(nominalValue, currentX, 15);
            Rectangle2D stringBounds = LABEL_FONT.getStringBounds(nominalValue, g.getFontRenderContext());
            currentX += stringBounds.getWidth() + 15;
}


Instance 16

Class360.paint(Graphics2D g2d,Rectangle paintArea,WMSMapContent mapContent)#3{
        Rectangle2D bgRect = new Rectangle2D.Double(
            x - 3.0, y - d.getHeight(), 
            d.getWidth() + 6.0, d.getHeight() + 6.0
        );
        g2d.setColor(Color.WHITE);
        g2d.fill(bgRect);
        g2d.setColor(Color.BLACK);
}


Instance 17

Class110.createShapeImage(Shape shape,Color c1,Color c2)#0{
    BufferedImage image = GraphicsUtils.createImage(rect.width,
        rect.height, true);
    Graphics2D g = image.createGraphics();
    g.setColor(c1);
    g.fill(shape);
    g.setColor(c2);
    g.draw(shape);
}


Instance 18

Class570.drawSolidCircle(Vec2 center,float radius,Vec2 axis,Color3f color)#0{
    g.scale(radius, radius);
    g.setColor(f);
    g.fill(circle);
    g.setColor(s);
    g.draw(circle);
}


Instance 19

Class320.drawInnerCircle(final Graphics2D g2,final double theCenterX,final double theCenterY,final double innerRadius)#0{
        g2.setColor(Color.white);
        g2.fill(innerCircle);
        g2.setColor(Color.black);
        g2.draw(innerCircle);
        drawCross(g2, (int) theCenterX, (int) theCenterY, lineLength, lineLength);
}


Instance 20

Class250.drawGenericNominalLegend(Graphics graphics,String[] names,PointStyle[] pointStyles,Color[] colors,int xOffset,int alpha)#1{
            g.setColor(color);
            g.fill(shape);
            g.setColor(Color.black);
            g.draw(shape);
            g.drawString(nominalValue, currentX, 15);
            Rectangle2D stringBounds = LABEL_FONT.getStringBounds(nominalValue, g.getFontRenderContext());
            currentX += stringBounds.getWidth() + 15;
}


Instance 21

Class690.paintComponent(Graphics g)#0{
        g2.setColor(MOTOR_FILL_COLOR);
        g2.fill(circle);
        g2.setColor(MOTOR_BORDER_COLOR);
        g2.draw(circle);
}


Instance 22

Class220.draw(Graphics2D g)#2{
            g.setColor(Color.GREEN);
            g.fill(e);
            g.setColor(Color.BLACK);
            g.draw(e);
}


Instance 23

Class220.draw(Graphics2D g)#3{
            g.setColor(Color.GREEN);
            g.fill(e);
            g.setColor(Color.BLACK);
            g.draw(e);
}


Instance 24

Class130.drawPoint(Graphics2D g,PointStyle pointStyle,double x,double y,Color color,Color borderColor)#0{
        g.setColor(color);
        g.fill(pointShape);
        g.setColor(borderColor);
        g.draw(pointShape);
}


Instance 25

Class210.createWorldMapImage(final GeneralPath[] geoBoundaryPaths)#2{
                g2d.setColor(_fillColor);
                g2d.fill(boundaryPath);
                g2d.setColor(Color.red);
                g2d.draw(boundaryPath);
}


Instance 26

Class680.paint(Graphics g)#0{
            g2.setColor(arrowColor);
            g2.fill(arrow);
            g2.setColor(Color.white);
            g2.draw(arrow);
}


Instance 27

Class680.paint(Graphics g)#1{
            g2.setColor(highlight);
            g2.fill(arrow);
            g2.setColor(Color.yellow);
            g2.draw(arrow);
}


Instance 28

Class540.paint(Graphics2D gfx){
            gfx.setColor(color);
            gfx.fill(_bpoly);
            gfx.setColor(Color.black);
            gfx.draw(_bpoly);
}


Instance 29

Class600.paint(Graphics2D g2d,Rectangle paintArea,WMSMapContent mapContent)#0{
                g2d.setStroke(new BasicStroke(2 * haloRadius, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
                g2d.draw(outline);
            g2d.setFont(font);
            g2d.setColor(fontColor);
            g2d.fill(outline);
            g2d.setColor(oldColor);
            g2d.setFont(oldFont);
            g2d.setStroke(oldStroke);
}


Instance 30

Class70.draw(Graphics2D g2)#3{
        g2.setColor(Color.lightGray);
        g2.fill(outerCircle);
        g2.setColor(Color.black);
        g2.draw(outerCircle);
}


Instance 31

Class620.render(Graphics2D gfx)#0{
        gfx.setColor(getBackground());
        gfx.fill(_shape);
        gfx.setColor(_outline);
        gfx.draw(_shape);
        SwingUtil.restoreAntiAliasing(gfx, oalias);
}


Instance 32

Class350.drawMiddleEllipse(Graphics2D g)#0{
    g.setColor(DARK_GREEN_ALPHA_80);
    g.fill(ellipse);
    g.setColor(GREEN_ALPHA_40);
    g.setStroke(THIN_STROKE);
    g.draw(ellipse);
}


Instance 33

Class750.main(String[] args)#6{
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.translate(150, 150);
        g2d.setColor(Color.BLUE);
        g2d.fill(shape);
        g2d.setColor(Color.BLACK);
        g2d.setFont(font);
}


Instance 34

Class720.onMouseOver(Graphics2D g2d,Rectangle cell,U guess,U gold)#1{
        Font bak = g2d.getFont();
        g2d.setFont(bak.deriveFont(bak.getSize() * 2.0f));
        g2d.setColor(Color.WHITE);
        g2d.fill(cell);
        g2d.setColor(Color.BLACK);
}


Instance 35

Class620.paint(Graphics g)#0{
            g2.setColor(getBorderColor().brighter());
            g2.setColor(getBorderColor());
        g2.fill(body);
}


Instance 36

Class620.paint(Graphics g)#4{
            g2.setColor(Comment.background.brighter());
            g2.setColor(Comment.background);
        g2.fill(textarea);
}


Instance 37

Class620.paint(Graphics g)#6{
            g2.setColor(Color.lightGray.brighter());
            g2.setColor(Color.lightGray);
        g2.fill(resize);
}


Instance 38

Class470.paint(Graphics2D g,Sequence sequence,IcyCanvas canvas)#0{
                    g2.setColor(getSelectedColor());
                    g2.setColor(getColor());
                g2.fill(ellipse);
}


Instance 39

Class340.drawTransformed(Shape s,Graphics2D g){
    Color oldColor = g.getColor();
    g.setColor(color);
    g.fill(s);
    g.setColor(oldColor);    
}


Instance 40

Class460.paintThumb(Graphics g,JComponent c,Rectangle thumbBounds)#0{
        g2.setColor(borderUIColor != null ? borderUIColor : fgUIColor);
        g2.fill(thumbBounds);
        g2.setColor(bgUIColor);
        g2.drawLine(x-w, y+2, x+w, y+2);
}


Instance 41

Class220.initButton()#1{
        g.setColor(new Color(128, 128, 128, 128));
        g.fill(roundRect);
        comp.paint(g);
        g.setColor(Color.white);
        g.draw(roundRect);
        g.dispose();
}


Instance 42

Class630.drawShadow(Graphics2D g2d,Shape shape,double deltaShadow,double dpiFactor)#9{
        gg.setColor(colorLine);
        gg.draw(shape);
        gg.setColor(color);
        gg.fill(shape);
      gg.dispose();
}


Instance 43

Class260.main(String[] args)#0{
       g2d.translate(x, y);
       g2d.setColor(Color.RED);
       tl.draw(g2d, 0, 0);
       g2d.setColor(Color.BLUE);
       g2d.fill(bounds);
       g2d.dispose();
}


Instance 44

Class300.toRaster(Shape mask)#2{
                if (bounds.width > 0 && bounds.height > 0) {
                    BufferedImage clip =
                        new BufferedImage(bounds.x + bounds.width,
                                          bounds.y + bounds.height,
                                          BufferedImage.TYPE_BYTE_BINARY);
                    Graphics2D g = clip.createGraphics();
                    g.setColor(Color.black);
                    g.fillRect(0, 0, bounds.x + bounds.width, bounds.y + bounds.height);
                    g.setColor(Color.white);
                    g.fill(mask);
                    raster = clip.getRaster();
                }
}


Instance 45

Class100.main(String[] args)#2{
        if (img.getRGB(60, 20) != Color.BLACK.getRGB()) {
            throw new RuntimeException("Error. Invalid pixel at (60,20)");
        }
        img = createCustomImage();
        g2d = img.createGraphics();
        g2d.setColor(Color.BLACK);
        g2d.fillRect(0,0,IMG_WIDTH,IMG_HEIGHT);
        g2d.setColor(Color.WHITE);
        g2d.fill(oddShape);
}


Instance 46

Class240.drawInnerSubDecoration(Graphics2D g)#0{
    transform(g, AffineTransform.getTranslateInstance(110, 54));
    g.setColor(GREEN_ALPHA_08);
    g.fill(shape);
    g.setStroke(THIN_STROKE);
    g.setColor(GREEN_ALPHA_48);
    g.draw(shape);
}


Instance 47

Class240.drawMiddleDecoration(Graphics2D g)#0{
    transform(g, AffineTransform.getTranslateInstance(77, 41));
    g.setColor(GREEN_ALPHA_20);
    g.fill(shape);
    g.setStroke(THIN_STROKE);
    g.setColor(GREEN_ALPHA_48);
    g.draw(shape);
}


Instance 48

Class540.paint(Graphics2D g,Object t,int width,int height)#0{
      g.setColor(frameColor);
      g.draw(rc);
      g.setColor(fillColor);
      g.fill(rc);
}


Instance 49

Class100.main(String[] args)#3{
        BufferedImage img = new BufferedImage(IMG_WIDTH, IMG_HEIGHT,
                                              BufferedImage.TYPE_INT_RGB);
        Graphics2D g2d = img.createGraphics();
        g2d.setColor(Color.BLACK);
        g2d.fillRect(0,0,IMG_WIDTH,IMG_HEIGHT);
        g2d.setColor(Color.WHITE);
        g2d.fill(oddShape);
}


Instance 50

Class430.paintObject(Graphics2D g2,State s,ObjectInstance ob,float cWidth,float cHeight)#3{
      g2.setColor(this.getColorForString(ob.getStringValForAttribute(BlocksWorld.ATTCOLOR)));
      float ry = cHeight - blockHeight - this.getHeight(s, ob)*blockHeight;
      g2.fill(new Rectangle2D.Float(rx + (hGap), ry, blockWidth - 2*hGap, blockHeight));
      g2.setColor(Color.black);
}


Instance 51

Class20.paintComponent(Graphics g)#2{
        g2d.setColor(UIUtil.getListSelectionBackground());
        g2d.fillRect(0, 0, bounds.width, bounds.height);
      g2d.setColor(Color.WHITE);
      g2d.fill(shape);
}


Instance 52

Class320.paintWorld(Graphics2D g)#0{
    for(String country:this.country2shape.keySet())
      {
      Shape shape=country2shape.get(country);
      float color=0;
      if(seen.count(country)!=0)
        {
        color=1f-(float)(Math.log(seen.count(country))/Math.log((double)seen.getTotal()));
        }
      g.setColor(seen.count(country)==0?Color.WHITE:new Color(color,0f,0f));
      g.fill(shape);
      }
    for(String country:this.country2shape.keySet())
      {
      Shape shape=country2shape.get(country);
      g.setColor(Color.BLACK);
      g.draw(shape);
        
      }
}


Instance 53

Class40.paintChildren(Graphics g)#0{
      graphics.setColor(new Color(255, 255, 255, 30));
      graphics.fill(r);
    graphics.dispose();
}


Instance 54

Class730.paint(Graphics g)#4{
            g2d.setColor(new Color(128, 0, 255, 128));
            g2d.fill(bounds);
        g2d.dispose();
}


Instance 55

Class510.create_DISABLED_Image(final int WIDTH)#2{
        G2.setColor(new Color(102, 102, 102, 178));
        G2.fill(BACKGROUND);
        G2.dispose();
}


Instance 56

Class510.create_DISABLED_Image(final int WIDTH)#3{
        G2.setColor(new Color(102, 102, 102, 178));
        G2.fill(GAUGE_BACKGROUND);
        G2.dispose();
}


Instance 57

Class280.paintBorder(Component c,Graphics g,int x,int y,int width,int height)#2{
            Area corner = new Area(new Rectangle2D.Float(x, y, width, height));
            corner.subtract(new Area(round));
            g2.fill(corner);
        g2.setColor(Color.lightGray);
        g2.draw(round);
        g2.dispose();
}


Instance 58

Class160.drawToolTip(Graphics2D g)#1{
      Rectangle2D bg = new Rectangle2D.Double((toolTipX) - stringBounds.getWidth() - 15, (toolTipY - (stringBounds.getHeight() / 2)), stringBounds.getWidth() + 6, Math.abs(stringBounds.getHeight()) + 4);
      g.fill(bg);
      g.setColor(Color.black);
      g.draw(bg);
      g.drawString(currentToolTip, (float) ((toolTipX ) - stringBounds.getWidth() - 12 ), (float) ((toolTipY + stringBounds.getHeight() * 0.5) + 1));
}


Instance 59

Class250.drawToolTip(Graphics2D g,ToolTip toolTip)#0{
            Rectangle2D bg = new Rectangle2D.Double(toolTip.getX() - stringBounds.getWidth() / 2 - 4, toolTip.getY() - stringBounds.getHeight() / 2, stringBounds.getWidth() + 5, stringBounds.getHeight() + 3);
            g.fill(bg);
            g.setColor(Color.black);
            g.draw(bg);
            g.drawString(toolTip.getText(), (int) (toolTip.getX() - stringBounds.getWidth() / 2 - 2), toolTip.getY() + 6);
}


Instance 60

Class250.drawToolTip(Graphics2D g)#2{
      Rectangle2D bg = new Rectangle2D.Double(toolTipX - stringBounds.getWidth() / 2 - 4, toolTipY - stringBounds.getHeight() / 2 - 2, stringBounds.getWidth() + 5, Math.abs(stringBounds.getHeight()) + 3);
      g.fill(bg);
      g.setColor(Color.black);
      g.draw(bg);
}


Instance 61

Class750.doPaint(Graphics2D g2,Object o,int i,int i1)#2{
        g2.setColor(new Color(1.0f, 1.0f, 1.0f));
        g2.fill(area);
        g2.setComposite(composite);
}


Instance 62

Class0.drawToolTip(Graphics2D g,double dx,double dy,double sx,double sy)#2{
      Rectangle2D bg = new Rectangle2D.Double((toolTipX + dx) * sx - stringBounds.getWidth() / 2 - 4, (toolTipY + dy) * sy + 3, stringBounds.getWidth() + 5, Math.abs(stringBounds.getHeight()) + 3);
      g.fill(bg);
      g.setColor(Color.black);
      g.draw(bg);
}


Instance 63

Class50.paint(Graphics2D g,JXMapViewer map,int w,int h)#0{
                    Rectangle green_mask = new Rectangle(st_gp_pt_screen, new Dimension(25,25));
                    g.fill(green_mask);
                    g.setColor(Color.BLACK);
                    g.draw(green_mask);
                    g.dispose();
}


Instance 64

Class120.paint(Graphics2D g,JXMapViewer map,int w,int h)#0{
                        Rectangle yellow_mask = new Rectangle(st_gp_pt_screen, new Dimension(25,25));
                        g.fill(yellow_mask);
                        g.setColor(Color.BLACK);
                        g.draw(yellow_mask);
                    g.dispose();
}


Instance 65

Class740.draw(Graphics2D g2d,AlphaComposite composite,String name)#1{
        g2d.setColor(new Color(255, 0, 0, 190));
        g2d.fill(dest);
        g2d.setComposite(composite);
}


Instance 66

Class560.paintComponent(Graphics g)#2{
      if (s1[i].empty() == false)
        graphics2D.fill(new Ellipse2D.Double(s1[i].x - 1, s1[i].y - 1, 3, 3));
    graphics2D.setColor(Color.blue);
}


Instance 67

Class630.paintComponent(Graphics g)#4{
            for (int i = 0; i < ticker.length; i++) {
                int channel = 224 - (128 / (i + 1));
                g2.setColor(new Color(channel, channel, channel, alphaLevel));
                g2.fill(ticker[i]);

                Rectangle2D bounds = ticker[i].getBounds2D();

                if (bounds.getMaxY() > maxY) {
                    maxY = bounds.getMaxY();
                }
            }
}


Instance 68

Class280.createClipImage(Graphics2D g,Shape shape)#0{
        g2.fillRect(0, 0, shape.getBounds().width, shape.getBounds().height);
        g2.setComposite(AlphaComposite.Src);
        g2.setRenderingHint(
            RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setColor(Color.WHITE);
        g2.fill(shape);
        g2.dispose();
}


Instance 69

Class130.paintComponent(Graphics g){
        Graphics2D g2d = (Graphics2D) g.create();
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setColor(Color.red);
        g2d.fill(ellipse);
        g2d.dispose();
}


Instance 70

Class60.paintControlPoint(Graphics2D g2,Point2D control)#2{
        g2.setColor(new Color(0.0f, 0.0f, 0.5f, 0.5f));
        g2.fill(circle);
                (int) xPositionToPixel(pos), (int) yPositionToPixel(pos));
}


Instance 71

Class510.drawBlurs(Graphics2D g2d,Shape shape,float contourWidth)#1{
                float value = n / (float) (count + 1);
                Color color = new Color(value, value, value);
                g2d.setColor(color);
                g2d.fill(semiBlur);
}


Instance 72

Class420.doPaintBackground(Graphics2D g,Rectangle clip,boolean vertical,Rectangle rectangle)#0{
    g.setColor(new Color(0, 0, 0, 80));
    g.fill(clip);
}


Instance 73

Class280.paintComponent(Graphics g)#2{
        g2.setColor(new Color(97,0,0,50));
        g2.fill(region);
}


Instance 74

Class480.paintRobocodeLogo(Graphics2D g)#0{
    g.setColor(new Color(0, 0x40, 0));
    g.fill(robocodeTextPath);
}


Instance 75

Class540.paintIcon(Component c,Graphics g,int x,int y)#1{
             g2.setColor( new Color( 255, 255, 0, 127) );
             g2.fill(r);
}


Instance 76

Class300.doPaintBackground(Graphics2D g,Rectangle clip,boolean vertical,Rectangle rectangle)#5{
    g.setColor(new Color(0, 0, 0, 80));
    g.fill(clip);
}


Instance 77

Class550.applyColorFilter(Image image,Color color,float alpha)#1{
            g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
            g.setColor(color);
            g.fill(rect);
            g.dispose();
}


Instance 78

Class280.composeMaskedImage(ImageCreator isrc,Shape mask,BufferedImage base){
        int wid = base.getWidth();
        int hei = base.getHeight();
        BufferedImage target = isrc.createImage(wid, hei, Transparency.TRANSLUCENT);
        Graphics2D g2 = target.createGraphics();
            g2.setColor(Color.BLACK); // whatever, really
            g2.fill(mask);
            g2.setComposite(AlphaComposite.SrcIn);
            g2.drawImage(base, 0, 0, null);
            g2.dispose();
}


Instance 79

Class710.paintComponent(Graphics graphics)#3{
            g.setColor(new Color(128, 128, 128, 128));
            g.fill(outer);
}


Instance 80

Class150.drawBackground(Rectangle bounds,Graphics2D graphics2D)#0{
        graphics2D.setColor(new Color(255, 255, 255, 64));
        graphics2D.fill(backgroundShape);
}


Instance 81

Class180.renderG2D(Item item,G2DTarget target,PreviewProperties properties)#4{
        graphics.setColor(new Color(color.getRed(), color.getGreen(), color.getBlue(), alpha));
        graphics.fill(ellipse);
}


Instance 82

Class500.paint(Graphics2D g2d)#0{
        g2d.setColor(new Color(96, 96, 96));
        g2d.fill(area);
}


Instance 83

Class160.draw(Graphics2D g,int maxW,int maxH,Display display)#0{
    g.setColor(new Color(255,255,0,100));
    g.fill(this);
}


Instance 84

Class140.paintComponent(Graphics g)#0{
            g2.setColor(new Color(34,177,76));
            g2.fill(r);
}


Instance 85

Class50.print(Graphics2D g2,double scalex,double scaley,int xOffset,int yOffset,int imgHeight)#0{
      for (int i = 0; i < spotcnt; i++)
        g2.fill(new Rectangle2D.Double(spots[i].x * scalex - 1 + xOffset, spots[i].y * scalex - 1 + yOffset, 3, 3));
      g2.setColor(Color.black);
}


Instance 86

Class590.computeRect(PlanarImage[] sourceImages,WritableRaster tile,Rectangle destRect)#1{
        graphics2D.translate(-tile.getMinX(), -tile.getMinY());
        graphics2D.setColor(Color.WHITE);
        graphics2D.fill(shape);
        graphics2D.dispose();
}


Instance 87

Class300.paintImage(Graphics2D g2d,Color color1,Color color2,Color color3)#2{
        g2d.fill(new Ellipse2D.Double(0, 0, dim, dim));
        g2d.setColor(color3);
        g2d.translate(0, 16);
}


Instance 88

Class560.paintComponent(final Graphics aGraphics)#0{
        for ( int i = 0; i < this.barCount; i++ )
        {
          canvas.setColor( calculateBarColor( i ) );
          canvas.fill( rect );
          canvas.rotate( ( 2.0 * Math.PI ) / this.barCount );
        }
        canvas.fillRect( 0, 0, getWidth(), getHeight() );
      canvas.dispose();
}


Instance 89

Class150.paintComponent(Graphics graphics)#3{
    g2.setColor(this.getBackground());
    g2.fill(rect);
    g2.dispose();
}


Instance 90

Class100.create_LCD_THRESHOLD_Image(final int WIDTH,final int HEIGHT,final Color COLOR)#1{
        G2.setColor(COLOR);
        G2.fill(LCD_THRESHOLD);
        G2.dispose();
}


Instance 91

Class690.create_MEASURED_VALUE_Image(final int WIDTH,final Color COLOR,final double ROTATION_OFFSET)#1{
        G2.setColor(COLOR);
        G2.fill(INDICATOR);
        G2.dispose();
}


Instance 92

Class580.create_MEASURED_VALUE_Image(final int WIDTH,final Color COLOR)#3{
        G2.setColor(COLOR);
        G2.fill(MAXMEASURED);
        G2.dispose();
}


Instance 93

Class380.paintComponentChrono(Graphics g)#0{
    g2.fill(new Rectangle2D.Double(0., 0., (double) getWidth(),
        (double) getHeight()));
    g2.setColor(Color.black);
}


Instance 94

Class530.paint(Graphics g,JComponent c)#1{
    Shape contour = SubstanceOutlineUtilities
        .getBaseOutline(
            width,
            height,
            Math.max(
                0,
                2.0f
                    * SubstanceSizeUtils
                        .getClassicButtonCornerRadius(componentFontSize)
                    - borderDelta), null, borderDelta);
    graphics.setColor(SubstanceTextUtilities
        .getTextBackgroundFillColor(this.spinner));
    graphics.fill(contour);
    graphics.dispose();
}


Instance 95

Class620.paintComponent(Graphics g)#1{
    g2.fill(new Rectangle2D.Double(0., 0., (double) getWidth(),
        (double) getHeight()));
    g2.setColor(Color.black);
}


Instance 96

Class400.paint(Graphics2D g2,State s,float cWidth,float cHeight)#1{
        g2.fill(new Rectangle2D.Double(0, 0, FrostbiteDomain.gameWidth, FrostbiteDomain.gameHeight));
        g2.setColor(Color.white);
}


Instance 97

Class620.drawWorld2D(Graphics2D g)#0{
        g.fill(new Rectangle2D.Double(x*LightBotWorldView2D.CELL_WIDTH, y*LightBotWorldView2D.CELL_WIDTH, LightBotWorldView2D.CELL_WIDTH, LightBotWorldView2D.CELL_WIDTH));
    g.setColor(GRID_COLOR);
}


Instance 98

Class720.paintFocus(Graphics g)#1{
        g2d.setColor(Color.black);
        g2d.fill(r);
        r = new Rectangle2D.Double(x2 - 2, y2 - 1, 4, 4);
}


Instance 99

Class460.drawWeightRectangle(Graphics2D newSpace,DataTable dataTable,int column,double maxWeight,int plotterSize)#0{
            Rectangle2D weightRect = new Rectangle2D.Double(1, 1, plotterSize - 2, plotterSize - 2);
            newSpace.fill(weightRect);
            newSpace.setColor(Color.WHITE);
}


Instance 100

Class60.dot(Graphics2D g2d,Point2D p,double r,Color c)#0{
        g2d.fill(new Ellipse2D.Double(p.getX() - r, p.getY() - r, 2 * r, 2 * r));
        g2d.setColor(old);
}


Instance 101

Class270.paintTrack(Graphics graphics)#2{
        graphics2d.fill(track);
        graphics2d.setColor(TRACK_BORDER_COLOR);
        graphics2d.draw(track);
}


Instance 102

Class470.paintFocus(Graphics g)#3{
        g2d.setColor(Color.black);
        g2d.fill(r);
        r = new Rectangle2D.Double(getX() + getWidth() - 2, getY()
                + getHeight() - 2, 4, 4);
}


Instance 103

Class470.paintFocus(Graphics g)#2{
        g2d.setColor(Color.black);
        g2d.fill(r);
        r = new Rectangle2D.Double(getX() + getWidth() - 2, getY() - 1, 4, 4);
}


Instance 104

Class470.paintFocus(Graphics g)#0{
        g2d.setColor(Color.black);
        g2d.fill(r);
        r = new Rectangle2D.Double(getX() - 1, getY() + getHeight() - 2, 4, 4);
}


Instance 105

Class20.paint(final Graphics2D g,final Rectangle clip)#1{
    if(shape.getLabelsSize()>0) {
      g.setColor(shape.getGridLabelsColour().toAWT());
      g.fill(pathLabels);
    }
    if(vectorTrans!=null)
      endRotation(g, vectorTrans);
}


Instance 106

Class740.paint(Graphics2D graphics)#0{
    if (fillColor != Color.NONE) {
      graphics.setColor(fillColor.toAWTColor());
      graphics.fill(shape);
    }
    if (strokeColor != Color.NONE) {
      float[] dashArray = getDashArray();
      if (dashArray.length == 0)
        dashArray = null;
      graphics.setColor(strokeColor.toAWTColor());
      graphics.setStroke(new BasicStroke(getStrokeWidth(),
          getStrokeCap().value, getStrokeJoin().value,
          getMiterLimit(), dashArray,
          getDashOffset()));
      graphics.draw(shape);
    }
}


Instance 107

Class330.renderBoxBorderAndBackground(final RenderBox box)#0{
    if ( box.getBoxDefinition().getBorder().isEmpty() == false ) {
      borderRenderer.paintBackgroundAndBorder( box, g2 );
    } else {
      final Color backgroundColor = (Color) box.getStyleSheet().getStyleProperty( ElementStyleKeys.BACKGROUND_COLOR );
      if ( backgroundColor != null ) {
        final double x = StrictGeomUtility.toExternalValue( box.getX() );
        final double y = StrictGeomUtility.toExternalValue( box.getY() );
        final double w = StrictGeomUtility.toExternalValue( box.getWidth() );
        final double h = StrictGeomUtility.toExternalValue( box.getHeight() );
        boxArea.setFrame( x, y, w, h );
        g2.setColor( backgroundColor );
        g2.fill( boxArea );
      }
    }
}


Instance 108

Class710.draw(final Graphics2D g2d,final Rectangle2D bounds)#0{
    if ( backgroundColor != null ) {
      g2d.setColor( backgroundColor );
      g2d.fill( bounds );
    }
}


Instance 109

Class530.draw(Graphics2D g,Figure f,Point2D.Double p1,Point2D.Double p2)#1{
                color = f.get(STROKE_COLOR);
                color = f.get(FILL_COLOR);
            if (color != null) {
                g.setColor(color);
                g.fill(path);
            }
}


Instance 110

Class410.draw(Graphics2D graphics2d)#0{
                if(fillColor != null)
                {
                    graphics2d.setColor(fillColor);
                    graphics2d.fill(shape);
                }
}


Instance 111

Class220.drawSelectionHandle(Graphics2D g,float x,float y,Color fillColor,int index)#0{
        if (fillColor != null) {
            g.setColor(fillColor);
            g.fill(SelectionHandle);
        }
}


Instance 112

Class300.paint(final Graphics2D g,final Rectangle clip)#4{
      g.setColor(java.awt.Color.BLACK);
      g.fill(pathLabels);
    if(vectorTrans!=null)
      endRotation(g, vectorTrans);
}


Instance 113

Class300.paint(Graphics2D graphics,limelight.ui.model.text.TextModel model){
    if(!model.isCaretOn() || model.hasSelection())
      return;
    Box caret = model.getCaretShape();
    graphics.setColor(model.getContainer().getStyle().getCompiledTextColor().getColor());
    graphics.fill(caret);
}


Instance 114

Class350.paint(Graphics2D g2d,State state)#3{
                    g2d.setComposite(((AlphaComposite) old).derive(1f));
                g2d.setColor(Color.LIGHT_GRAY);
                g2d.fill(circle);
                g2d.setComposite(old);
}


Instance 115

Class90.fillTile(Graphics2D gfx,int tx,int ty,Color color)#1{
        gfx.setColor(color);
        gfx.fill(poly);
        gfx.setComposite(ocomp);
}


Instance 116

Class550.tintSquare(int[] coords,int square_width,AlphaComposite ac,Color color,BufferedImage bi,Graphics2D g2d)#0{
    g2d.setComposite(ac);
    g2d.setColor(color);
    g2d.fill(rect);
    g2d.drawImage(bi, null, 0, 0);
}


Instance 117

Class520.drawParticles(Vec2[] centers,float radius,ParticleColor[] colors,int count)#1{
      AffineTransform old = g.getTransform();
      g.translate(center.x, center.y);
      g.scale(radius, radius);
      g.setColor(color);
      g.fill(circle);
      g.setTransform(old);
    restoreState(g);
}


Instance 118

Class680.drawTrafficLight2(Graphics2D g,TrafficLight trafficLight,Rectangle2D trafficLightRect,double radius)#4{
        g.setColor(Color.DARK_GRAY);
        g.fill(trafficLightRect);
        final Double width = trafficLightRect.getWidth();
        final Double height = trafficLightRect.getHeight();
}


Instance 119

Class190.paintSortIndicator(Graphics2D graphics2d,TableUtils.SortDirection sortDirection)#1{
        graphics2d.setRenderingHint(
                RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        graphics2d.translate(x, y);
        graphics2d.setColor(SORT_ICON_COLOR);
        graphics2d.fill(sortShape);
}


Instance 120

Class370.drawFillShape(final Graphics2D g2d){
        final Ellipse2D shape = new Ellipse2D.Float();
        setShapeFrame(shape, strokeWidth);
        g2d.setStroke(new BasicStroke(strokeWidth));
        g2d.setColor(counterColor);
        g2d.fill(shape);
}


Instance 121

Class240.paint(Graphics g,Rectangle bounds){
      Graphics2D g2d = (Graphics2D) g;
      g2d.setColor(Color.black);
      g2d.fill(bounds);
}


Instance 122

Class710.paintThumb(Graphics g,JComponent c,Rectangle thumbBounds)#1{
        Graphics2D g2 = (Graphics2D) g;
        g2.setColor(foreground);
        g2.fill(thumbBounds);
}


Instance 123

Class150.paintTrack(Graphics g,JComponent c,Rectangle trackBounds)#0{
        Graphics2D g2 = (Graphics2D) g;
        g2.setColor(bgUIColor);
        g2.fill(trackBounds);
}


Instance 124

Class580.paintComponent(Graphics graphics)#2{
        Graphics2D g = (Graphics2D) graphics;
        Shape clip = g.getClip();
        g.setColor(LightZoneSkin.Colors.NeutralGray);
        g.fill(clip);
}


Instance 125

Class750.paintComponent(Graphics graphics)#1{
        Graphics2D g = (Graphics2D) graphics;
        Shape clip = g.getClip();
        g.setColor(LightZoneSkin.Colors.NeutralGray);
        g.fill(clip);
}


Instance 126

Class320.paintTile(Graphics2D g,MapView mv,IVertexRenderer vertexRenderer){
    BlockingDeque<EleVertex> list = getVertices();
    for (EleVertex eleVertex : list) {
      Point p0 = mv.getPoint(eleVertex.get(0));
      Point p1 = mv.getPoint(eleVertex.get(1));
      Point p2 = mv.getPoint(eleVertex.get(2));
      Triangle shape = new Triangle(p0, p1, p2);

      // obtain vertex color
      g.setColor(vertexRenderer.getElevationColor(eleVertex));
      // TODO: Move to renderer
      g.fill(shape);
    }
}


Instance 127

Class580.paintComponent(Graphics g)#1{
            for (int i = 0; i < bars.length; i++) {
                g2.setColor(colors[i + colorOffset]);
                g2.fill(bars[i]);
            }
}


Instance 128

Class290.paintObject(Graphics2D g2,State s,ObjectInstance ob,float cWidth,float cHeight)#1{
      float ry = cHeight - height - ob.getIntValForAttribute(BlockDude.ATTY)*height;
      g2.fill(new Rectangle2D.Float(rx, ry, width, height));
      g2.setColor(Color.orange);
}


Instance 129

Class260.drawNaoLoc(Graphics2D g2,boolean shouldFlip)#2{
    g2.fill(new Ellipse2D.Float(screenX-naoRobotSize/2, screenY-naoRobotSize/2, naoRobotSize, naoRobotSize));
    g2.setColor(Color.black);
}


Instance 130

Class530.draw(ColorMapper colorMapper,Graphics2D g2d)#1{
    g2d.setColor(colorMapper.getMappedColor(getYellowNote()));
    g2d.fill(p);
}


Instance 131

Class680.draw(ColorMapper colorMapper,Graphics2D g2d)#1{
    g2d.setColor(colorMapper.getMappedColor(getYellow()));
    g2d.fill(ellipse);
}


Instance 132

Class540.draw(ColorMapper colorMapper,Graphics2D g2d)#1{
    g2d.setColor(colorMapper.getMappedColor(getYellow()));
    g2d.fill(p);
}


Instance 133

Class200.paintBorder(Component c,Graphics g,int x,int y,int width,int height)#2{
            Path2D path = new Path2D.Float(Path2D.WIND_EVEN_ODD);
            path.append(inner, false);
            g2d.fill(path);
            g2d.setColor(oldColor);
}


Instance 134

Class670.draw(ColorMapper colorMapper,Graphics2D g2d)#0{
    g2d.setColor(colorMapper.getMappedColor(getYellow()));
    g2d.fill(p);
}


Instance 135

Class740.getMask()#0{
    BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
    Graphics2D g2d = bi.createGraphics();
    g2d.setColor(Color.white);
    g2d.fill(shape);
}


Instance 136

Class110.paintDotShape(final Graphics2D g,final boolean toFill,final Color fillCol)#0{
      g.setColor(fillCol.toAWT());
      g.fill(path);
}


Instance 137

Class500.paintArrow(final Graphics2D g,final Color lineColor){
    g.setColor(lineColor.toAWT());
    g.fill(path);
}


Instance 138

Class320.paintCircle(final Graphics2D g,final Color fillColour,final Color lineColour)#1{
    g.setColor(fillColour.toAWT());
    g.fill(path);
}


Instance 139

Class420.fillTextBackground(int align,int flag,Graphics2D g2d,float x,float y,float width,TextLayout layout)#0{
            g2d.fill(layout.getBounds());
            g2d.setColor(c);
            g2d.setTransform(tr);
}


Instance 140

Class420.fillTextBackground(int align,int flag,Graphics2D g2d,float x,float y,float width,TextLayout layout)#1{
            g2d.fill(layout.getBounds());
            g2d.setColor(c);
            g2d.setTransform(tr);
}


Instance 141

Class180.paintComponent(Graphics graphics)#2{
            complement.subtract(new Area(shape));
            g.fill(complement);
            g.setColor(GridColor);
            paintGrid(g);
}


Instance 142

Class80.drawOuterDecoration(Graphics2D g)#0{
    transform(g, AffineTransform.getTranslateInstance(26, 24));
    g.setColor(WHITE_ALPHA_7F);
    g.fill(shape);
    g.setStroke(THIN_STROKE);
    g.drawOval(16, 5, 490, 163);
}


Instance 143

Class190.getBevelImage(int width,int height,Area s)#0{
        g2.setColor(ShapeBevel.getFrontFaceOverlay(light));
        g2.fill(s);
        ShapeBevel.createShapeBevel(g2, s, 0.1, bevelSize, bevelSize, light);
        BevelCacheKey key2 = new BevelCacheKey(width, height, new Area(s));
        bevelCache.put(key2, img);
}


Instance 144

Class80.renderAttributeBand(Graphics2D g2D,Rectangle bandRectangle,Rectangle visibleRectangle,List<String> attributeNames,List<String> sampleList,List<MouseableRegion> mouseRegions)#2{
                        g2D.setColor(AttributeManager.getInstance().getColor(key, attributeValue));
                        g2D.fill(rect);
                        mouseRegions.add(new MouseableRegion(rect, key, attributeValue));
}


Instance 145

Class470.renderAttributes(Graphics2D graphics,Rectangle trackRectangle,Rectangle visibleRect,List<String> names,List<MouseableRegion> mouseRegions)#1{
                graphics.setColor(AttributeManager.getInstance().getColor(key, attributeValue));
                graphics.fill(rect);
                mouseRegions.add(new MouseableRegion(rect, key, attributeValue));
}


Instance 146

Class300.doPaintBackground(Graphics2D g,Rectangle clip,boolean vertical,Rectangle rectangle)#1{
    g.setColor(UIUtil.getPanelBackground());
    g.fill(clip);
}


Instance 147

Class420.doPaintBackground(Graphics2D g,Rectangle clip,boolean vertical,Rectangle rectangle)#4{
    g.setColor(UIUtil.getPanelBackground());
    g.fill(clip);
}


Instance 148

Class90.paintImage(Graphics2D g2d,Color color)#0{
        Dimension dimension = getDimension();
        g2d.scale(dimension.getHeight() / 128, dimension.getHeight() / 128);
        draw(path, g2d);
        g2d.setColor(color);
        g2d.fill(path);
}


Instance 149

Class600.paintComponent(Graphics g)#2{
            g2.fill(g.getClip());
            g2.setColor(java.awt.Color.BLACK);
}


Instance 150

Class340.paintComponent(Graphics g)#2{
      g2d.setColor(getBackground());
      g2d.fill(flagShape);
}


Instance 151

Class390.paintComponent(Graphics g)#1{
        g2d.setColor(getFillColor());
        g2d.fill(shape);
}


Instance 152

Class390.create_HORIZON_FOREGROUND_Image(final int WIDTH)#2{
        G2.setColor(getPointerColor().LIGHT);
        G2.fill(TRIANGLE);
}


Instance 153

Class30.renderFill(Graphics2D g,GraphMetrics metrics){
    g.setColor(fillColor);
    g.fill(path);
}


Instance 154

Class650.draw(Graphics2D g2,Rectangle2D area){
        ParamChecks.nullNotPermitted(area, "area");
        g2.setColor(this.color);
        g2.fill(area);
}


Instance 155

Class720.paint(Graphics2D g2)#4{
      g2.setColor(getHandleColor(valueHandleSelected()));
      g2.fill(valueHandle);
}


Instance 156

Class720.paintFocus(Graphics g)#0{
        g2d.setColor(Color.black);
        g2d.fill(r);
}


Instance 157

Class730.drawDiamond(Graphics2D g,Color fill,Color stroke)#0{
            g.setColor(stroke);
            g.fill(p);
}


Instance 158

Class730.drawDiamond(Graphics2D g,Color fill,Color stroke)#3{
            g.setColor(stroke);
            g.fill(p);
}


Instance 159

Class730.drawDiamond(Graphics2D g,Color fill,Color stroke)#4{
            g.setColor(fill);
            g.fill(p);
}


Instance 160

Class360.draw(Graphics2D gc){
                gc.setColor(colour);
                gc.fill(arc2D);
}


Instance 161

Class360.dragOver(DropTargetDragEvent event)#5{
            g2d.setColor(Color.black);
            g2d.fill(cueLine);
}


Instance 162

Class640.paint(Graphics2D g2d,State state)#0{
                g2d.setColor(Color.BLUE);
                g2d.fill(circle);
}


Instance 163

Class430.draw(Graphics2D g)#2{
        g.setColor(Color.BLUE);
        g.fill(e);
}


Instance 164

Class610.drawOnThis(Graphics2D g)#0{
      g.setColor(Object3DViewer.shadeColor(color, centerPoint.z));
      g.fill(polygon);
}


Instance 165

Class530.paint(Graphics g)#7{
        g2.fill(this.getXBox(w, h));
        g2.setColor(Color.white);
}


Instance 166

Class130.clearRegion(Graphics2D g,Rectangle2D r){
        g.setColor(getBackground());
        g.fill(r);
        firePrePaint(g);
}


Instance 167

Class460.doPaintBackground(Graphics2D g,Rectangle clip,boolean vertical,Rectangle rectangle){
    g.setColor(getBackgroundColor());
    g.fill(clip);
}


Instance 168

Class460.drawBackground(Graphics2D g2)#1{
    g2.setColor(getBackground());
    g2.fill(rectangle);
}


Instance 169

Class50.paintComponent(Graphics g)#7{
        g2.setColor(getBackground());
        g2.fill(clip);
}


Instance 170

Class50.paint(Graphics g)#6{
                    g2d.setColor(selectionOverlayColor);
                    g2d.fill(s);
}


Instance 171

Class560.paintBetween(Graphics2D gfx,Rectangle dirtyRect){
        gfx.setColor(Color.gray);
        gfx.fill(dirtyRect);
        _spritemgr.renderSpritePaths(gfx);
}


Instance 172

Class160.paintComponent(Graphics g)#0{
            Dimension size = getSize();
            g2.setColor(getBackground());
            g2.fill(roundBounds);
}


Instance 173

Class110.executePaint(Component component,Graphics2D g)#0{
      g.setColor(ColorUtil.toAlpha(myColor, 40));
      g.fill(myBoundingBox);
}


Instance 174

Class310.paintIcon(Component c,Graphics g,int x,int y)#2{
       g2d.setColor(color);
       g2d.fill(shape);
}


Instance 175

Class490.drawBackground(Graphics2D g2d,Dimension d)#1{
        g2d.setColor(Color.black);
        g2d.fill(p);
}


Instance 176

Class100.drawCurveTrapezium(@NotNull Graphics2D g,int x1,int x2,int start1,int end1,int start2,int end2,@Nullable Color fillColor,@Nullable Color borderColor)#1{
      g.setColor(fillColor);
      g.fill(path);
}


Instance 177

Class70.drawLabel(@NotNull Graphics2D g2,@NotNull String label,int paddingX,@NotNull Color bgColor,@Nullable Color rootIndicatorColor)#4{
    g2.setColor(bgColor);
    g2.fill(rectangle2D);
}


Instance 178

Class470.paintHudControlBackground(Graphics2D graphics,Rectangle bounds,ShapeProvider shapeProvider,Paint paint)#2{
        graphics.fill(shapeProvider.createShape(x, y + 1, width, height - 1));
        graphics.setColor(BORDER_COLOR);
}


Instance 179

Class470.paintFocus(Graphics g)#1{
        g2d.setColor(Color.black);
        g2d.fill(r);
}


Instance 180

Class470.drawBGShape(Graphics2D g)#1{
      g.setColor(bgcolor);
      g.fill(bgShape);
}


Instance 181

Class510.drawBlurs(Graphics2D g2d,Shape shape,float contourWidth)#3{
        g2d.setColor(Color.white);
        g2d.fill(shape);
}


Instance 182

Class370.paint(final Graphics2D g)#0{
    g.setColor(colour.toAWT());
    g.fill(shape);
}


Instance 183

Class200.exportImage(BufferedImage bufferedImage,Rectangle rectangle,RenderingHints hints,boolean transparent)#0{
            graphics.setColor(Color.white); // set the background color
            graphics.fill(rectangle);
        _drawPlot(graphics, false, rectangle);
}


Instance 184

Class260.paint(Graphics2D g2)#4{
            g2.setColor(selected == lb ? Color.WHITE : Color.GRAY);
            g2.fill(r);
            Image img = images.get(lb);
            int x = getIconX(lb), y = getIconY(lb);
}


Instance 185

Class210.paint(Graphics2D g2d,State state)#4{
            g2d.setColor(Color.DARK_GRAY);
            g2d.fill(background);
}


Instance 186

Class210.drawPartialProgress(Graphics2D g,float progress,float width,float height)#0{
        r.setRect(0,0, split, height);
        g.fill(r);
        g.setColor(Color.gray);
}


Instance 187

Class480.drawLabel(@NotNull Graphics2D g2,@NotNull String label,int paddingX,@NotNull Color bgColor,@Nullable Color rootIndicatorColor)#4{
    g2.setColor(bgColor);
    g2.fill(rectangle2D);
}


Instance 188

Class480.drawCanvas(Graphics2D g)#1{
                g.setColor(canvasColor);
                g.fill(r);
}


Instance 189

Class250.drawRadioMark(Graphics2D graphics,Color color,Shape markOval){
    graphics.setColor(color);
    graphics.fill(markOval);
}


Instance 190

Class250.paint(Graphics2D g2,double scale)#0{
    g2.setColor(getColor());
    g2.fill(caret);
}


Instance 191

Class590.doPaintBackground(Graphics2D g2d,Rectangle clip){
    g2d.setColor(getBackground());
    g2d.fill(clip);
}


Instance 192

Class120.paint(Graphics2D g,int width)#4{
      g.setColor(myColor);
      g.fill(path);
}


Instance 193

Class320.drawOnThis(Graphics2D g)#0{
    g.setColor(shade ? shadedColor : color);
    g.fill(polygon);
}


Instance 194

Class350.drawPoint(Graphics2D g2,double x,double y,double r,Color color,boolean hasBorder)#0{
      c.setFrame(x - r2, y - r2, w2, w2);
      g2.fill(c);
    g2.setColor(color);
}


Instance 195

Class170.drawRectangle(Graphics2D g,Color fill,Color stroke)#2{
            g.setColor(fill);
            g.fill(r);
}


Instance 196

Class680.drawTrafficLight1(Graphics2D g,TrafficLight trafficLight,Rectangle2D trafficLightRect,double radius)#7{
        g.setColor(Color.DARK_GRAY);
        g.fill(trafficLightRect);
}


Instance 197

Class20.paintComponent(Graphics g)#0{
      Color bgColor = getBackground();
      g2d.setColor(bgColor);
      g2d.fill(shape);
}


Instance 198

Class580.paintIcon(Component c,Graphics g,int x,int y)#1{
            g2.setColor(rollover ? COLOR_COLLAPSED_FILL_ROLLOVER : COLOR_COLLAPSED_FILL);
            g2.fill(path);
}